﻿using B.MES.Customer.Domain;
using B.MES.Customer.Domain.DTO;
using B.MES.Customer.Infrastructure.IRepository;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace B.MES.Customer.Infrastructure.Repository
{
    public class BaseRepository<T> : IBaseRepository<T> where T : class,new()
    {
        private readonly ISqlSugarClient _db;
        public BaseRepository(ISqlSugarClient db)
        {
            _db = db;
        }

        /// <inheritdoc/>
        public T GetById(object id)
        {
            return _db.Queryable<T>().InSingle(id); // 使用 Queryable 方法查询数据库中的单个实体对象
        }

        /// <inheritdoc/>
        public List<T> GetAll()
        {
            return _db.Queryable<T>().ToList(); // 使用 Queryable 方法查询数据库中的所有实体对象列表
        }

        /// <inheritdoc/>
        public List<T> GetList(Expression<Func<T, bool>> whereExpression)
        {
            return _db.Queryable<T>().Where(whereExpression).ToList(); // 使用 Queryable 方法根据条件查询数据库中的实体对象列表
        }

        /// <inheritdoc/>
        public bool Insert(T entity)
        {
            return _db.Insertable(entity).ExecuteCommand() > 0; // 使用 Insertable 方法插入实体对象到数据库
        }

        /// <inheritdoc/>
        public bool Update(T entity)
        {
            return _db.Updateable(entity).ExecuteCommand() > 0; // 使用 Updateable 方法更新数据库中的实体对象
        }

        /// <inheritdoc/>
        public bool Delete(T entity)
        {
            return _db.Deleteable(entity).ExecuteCommand() > 0; // 使用 Deleteable 方法从数据库中删除实体对象
        }

        /// <inheritdoc/>
        public PageApiResut<T> GetPage(int page, int size, Expression<Func<T, bool>> whereLambda, bool IsAsc, Expression<Func<T, object>> orderLambda)
        {
            PageApiResut<T> pageApiResut = new PageApiResut<T>();

            var query = _db.Queryable<T>().Where(whereLambda);

            pageApiResut.TotalCount = query.Count();
            if (IsAsc)
            {
                pageApiResut.Data = query.OrderByDescending(orderLambda).Skip((page - 1) * size).Take(size).ToList();
            }
            else
            {
                pageApiResut.Data = query.OrderByDescending(orderLambda).Skip((page - 1) * size).Take(size).ToList();
            }
            return pageApiResut;
        }

        public void Add(List<T> entities)
        {
            foreach (var entity in entities)
            {
                _db.Insertable(entity).ExecuteCommand();
            }
            entities.FirstOrDefault();
        }

        public int SaveChanges()
        {
            // 调用 SqlSugar 的 Commit 方法提交更改
            return _db.SaveQueues();
        }

        //public PageApiResut<T> GetRoles(int page, int size, Expression<Func<T, bool>> whereLambda, bool IsAsc, Expression<Func<T, object>> orderLambda)
        //{
        //    PageApiResut<T> pageApiResut = new PageApiResut<T>();

        //    var query = _db.Queryable<T>().Where(whereLambda);

        //    pageApiResut.TotalCount = query.Count();
        //    if (IsAsc)
        //    {
        //        pageApiResut.Data = query.OrderBy(orderLambda).Skip((page - 1) * size).Take(size).ToList();
        //    }
        //    else
        //    {
        //        pageApiResut.Data = query.OrderBy(orderLambda).Skip((page - 1) * size).Take(size).ToList();
        //    }
        //    return pageApiResut;
        //}

        //public List<T> BatchDeleteData(List<T> entities)
        //{
        //    List<T> deletedEntities = new List<T>();

        //    // 将传入的实体对象列表在数据库中逐个删除，并将其添加到被删除的实体对象列表中
        //    foreach (var entity in entities)
        //    {
        //        var result = _db.Deleteable(entity).ExecuteCommand();
        //        if (result > 0)
        //        {
        //            deletedEntities.Add(entity);
        //        }
        //    }

        //    return deletedEntities;
        //}
    }
}
